﻿using Library.AppWeb;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using MPR.Poker.DALEntity.SYS;
using MPR.Poker.Model;
using MPR.Poker.DALEntity.DataCache;


namespace MPR.Poker.DALEntity.DataCache
{
    public class GetDataCache
    {        
        /// <summary>
        /// Lấy Cache danh sách Quốc gia
        /// </summary>
        /// <param name="lstCountry"></param>
        /// <returns></returns>
        public static ResultMessage GetCountry(ref List<Model.LIS.LIS_Country> lstCountry)
        {
            try
            {
                if (lstCountry == null) lstCountry = new List<Model.LIS.LIS_Country>();

                if (CacheProvider.IsSet(CacheProvider.CacheKey_Country))
                {
                    lstCountry = (List<Model.LIS.LIS_Country>)CacheProvider.Get(CacheProvider.CacheKey_Country);
                }
                else
                {
                    ResultMessage objResultMessage = new DALEntity.LIS.DAL_Country().SelectToCache(ref lstCountry);

                    if (!objResultMessage.IsError)
                    {
                        CacheProvider.Set(CacheProvider.CacheKey_Country, lstCountry);
                    }
                    else
                    {
                        return objResultMessage;
                    }
                }
                return new ResultMessage(false, ResultMessage.ErrorTypes.No_Error, "Lấy Cache danh sách Quốc gia", string.Empty);
            }
            catch (Exception objEx)
            {
                ResultMessage objResultMessage = new ResultMessage();
                objResultMessage = new ResultMessage(true, ResultMessage.ErrorTypes.GetData, "Lấy Cache danh sách Quốc gia", objEx);
                DAL_Error.Insert(objResultMessage, 0, "GetDataCache --> GetCountry");
                return objResultMessage;
            }
        }
        /// <summary>
        /// Lấy Cahce danh sách Tỉnh thành
        /// </summary>
        /// <param name="lstProvince"></param>
        /// <returns></returns>
        public static ResultMessage GetProvince(ref List<Model.LIS.LIS_Province> lstProvince)
        {
            try
            {
                if (lstProvince == null) lstProvince = new List<Model.LIS.LIS_Province>();

                if (CacheProvider.IsSet(CacheProvider.CacheKey_Province))
                {
                    lstProvince = (List<Model.LIS.LIS_Province>)CacheProvider.Get(CacheProvider.CacheKey_Province);
                }
                else
                {
                    ResultMessage objResultMessage = new DALEntity.LIS.DAL_Province().SelectListToCache(ref lstProvince);

                    if (!objResultMessage.IsError)
                    {
                        CacheProvider.Set(CacheProvider.CacheKey_Province, lstProvince);
                    }
                    else
                    {
                        return objResultMessage;
                    }
                }
                return new ResultMessage(false, ResultMessage.ErrorTypes.No_Error, "Lấy Cache danh sách Tỉnh thành", string.Empty);
            }
            catch (Exception objEx)
            {
                ResultMessage objResultMessage = new ResultMessage();
                objResultMessage = new ResultMessage(true, ResultMessage.ErrorTypes.GetData, "Lấy Cache danh sách Tỉnh thành", objEx);
                DAL_Error.Insert(objResultMessage, 0, "GetDataCache --> GetProvince");
                return objResultMessage;
            }
        }
        /// <summary>
        /// Lấy danh sách Cache đơn vị tiền tệ
        /// </summary>
        /// <param name="lstCurrency"></param>
        /// <returns></returns>
        public static ResultMessage GetCurrency(ref List<Model.LIS.LIS_Currency> lstCurrency)
        {
            try
            {
                if (lstCurrency == null) lstCurrency = new List<Model.LIS.LIS_Currency>();

                if (CacheProvider.IsSet(CacheProvider.CacheKey_Currency))
                {
                    lstCurrency = (List<Model.LIS.LIS_Currency>)CacheProvider.Get(CacheProvider.CacheKey_Currency);
                }
                else
                {
                    ResultMessage objResultMessage = new DALEntity.LIS.DAL_Currency().SelectToCache(ref lstCurrency);

                    if (!objResultMessage.IsError)
                    {
                        CacheProvider.Set(CacheProvider.CacheKey_Currency, lstCurrency);
                    }
                    else
                    {
                        return objResultMessage;
                    }
                }
                return new ResultMessage(false, ResultMessage.ErrorTypes.No_Error, "Lấy Cache danh sách Tỉnh thành", string.Empty);
            }
            catch (Exception objEx)
            {
                ResultMessage objResultMessage = new ResultMessage();
                objResultMessage = new ResultMessage(true, ResultMessage.ErrorTypes.GetData, "Lấy Cache danh sách Tỉnh thành", objEx);
                DAL_Error.Insert(objResultMessage, 0, "GetDataCache --> GetProvince");
                return objResultMessage;
            }
        }

        public static ResultMessage GetPrize(ref List<Model.LIS.LIS_Prize> lstPrize)
        {
            try
            {
                if (lstPrize == null) lstPrize = new List<Model.LIS.LIS_Prize>();

                if (CacheProvider.IsSet(CacheProvider.CacheKey_Prize))
                {
                    lstPrize = (List<Model.LIS.LIS_Prize>)CacheProvider.Get(CacheProvider.CacheKey_Prize);
                }
                else
                {
                    ResultMessage objResultMessage = new DALEntity.LIS.DAL_Prize().SelectToCache(ref lstPrize);

                    if (!objResultMessage.IsError)
                    {
                        CacheProvider.Set(CacheProvider.CacheKey_Prize, lstPrize);
                    }
                    else
                    {
                        return objResultMessage;
                    }
                }
                return new ResultMessage(false, ResultMessage.ErrorTypes.No_Error, "Lấy Cache danh sách xếp loại giải thưởng", string.Empty);
            }
            catch (Exception objEx)
            {
                ResultMessage objResultMessage = new ResultMessage();
                objResultMessage = new ResultMessage(true, ResultMessage.ErrorTypes.GetData, "Lấy Cache danh sách xếp loại giải thưởng", objEx);
                DAL_Error.Insert(objResultMessage, 0, "GetDataCache --> GetCountry");
                return objResultMessage;
            }
        }

        /// <summary>
        /// Lấy danh sách người dùng từ Cache
        /// </summary>
        /// <param name="lstUser">List đối tượng người dùng</param>
        /// <returns></returns>
        public static ResultMessage GetUser(ref List<Model.SYS.SYS_User> lstUser)
        {
            try
            {
                if (lstUser == null) lstUser = new List<Model.SYS.SYS_User>();

                if (CacheProvider.IsSet(CacheProvider.CacheKey_User))
                {
                    lstUser = (List<Model.SYS.SYS_User>)CacheProvider.Get(CacheProvider.CacheKey_User);
                }
                else
                {
                    ResultMessage objResultMessage = new DALEntity.SYS.DAL_User().SelectToCache(ref lstUser);

                    if (!objResultMessage.IsError)
                    {
                        CacheProvider.Set(CacheProvider.CacheKey_User, lstUser);
                    }
                    else
                    {
                        return objResultMessage;
                    }
                }
                return new ResultMessage(false, ResultMessage.ErrorTypes.No_Error, "Lấy Cache danh sách người dùng", string.Empty);
            }
            catch (Exception objEx)
            {
                ResultMessage objResultMessage = new ResultMessage();
                objResultMessage = new ResultMessage(true, ResultMessage.ErrorTypes.GetData, "Lấy Cache danh sách người dùng", objEx);
                DAL_Error.Insert(objResultMessage, 0, "GetDataCache --> GetUser");
                return objResultMessage;
            }
        }
        /// <summary>
        /// Lấy Cache danh sách loại thành viên
        /// </summary>
        /// <param name="lstMemberType"></param>
        /// <returns></returns>
        public static ResultMessage GetMemberType(ref List<Model.SYS.SYS_MemberType> lstMemberType)
        {
            try
            {
                if (lstMemberType == null) lstMemberType = new List<Model.SYS.SYS_MemberType>();

                if (CacheProvider.IsSet(CacheProvider.CacheKey_MemberType))
                {
                    lstMemberType = (List<Model.SYS.SYS_MemberType>)CacheProvider.Get(CacheProvider.CacheKey_MemberType);
                }
                else
                {
                    ResultMessage objResultMessage = new DALEntity.SYS.DAL_MemberType().SelectToCache(ref lstMemberType);

                    if (!objResultMessage.IsError)
                    {
                        CacheProvider.Set(CacheProvider.CacheKey_MemberType, lstMemberType);
                    }
                    else
                    {
                        return objResultMessage;
                    }
                }
                return new ResultMessage(false, ResultMessage.ErrorTypes.No_Error, "Lấy Cache danh sách loại thành viên", string.Empty);
            }
            catch (Exception objEx)
            {
                ResultMessage objResultMessage = new ResultMessage();
                objResultMessage = new ResultMessage(true, ResultMessage.ErrorTypes.GetData, "Lấy Cache danh sách loại thành viên", objEx);
                DAL_Error.Insert(objResultMessage, 0, "GetDataCache --> GetMemberType");
                return objResultMessage;
            }
        }

        /// <summary>
        /// Lấy cache danh sách thành viên
        /// </summary>
        /// <param name="lstMember"></param>
        /// <returns></returns>
        public static ResultMessage GetMember(ref List<Model.SYS.SYS_Member> lstMember)
        {
            try
            {
                if (lstMember == null) lstMember = new List<Model.SYS.SYS_Member>();

                if (CacheProvider.IsSet(CacheProvider.CacheKey_Member))
                {
                    lstMember = (List<Model.SYS.SYS_Member>)CacheProvider.Get(CacheProvider.CacheKey_Member);
                }
                else
                {
                    ResultMessage objResultMessage = new DALEntity.SYS.DAL_Member().SelectToCache(ref lstMember);

                    if (!objResultMessage.IsError)
                    {
                        CacheProvider.Set(CacheProvider.CacheKey_Member, lstMember);
                    }
                    else
                    {
                        return objResultMessage;
                    }
                }
                return new ResultMessage(false, ResultMessage.ErrorTypes.No_Error, "Lấy Cache danh sách loại thành viên", string.Empty);
            }
            catch (Exception objEx)
            {
                ResultMessage objResultMessage = new ResultMessage();
                objResultMessage = new ResultMessage(true, ResultMessage.ErrorTypes.GetData, "Lấy Cache danh sách loại thành viên", objEx);
                DAL_Error.Insert(objResultMessage, 0, "GetDataCache --> GetMemberType");
                return objResultMessage;
            }
        }

        /// <summary>
        /// Lấy cache danh sách giải đấu
        /// </summary>
        /// <param name="lstTournament"></param>
        /// <returns></returns>
        public static ResultMessage GetTournament(ref List<Model.SYS.SYS_Tournament> lstTournament)
        {
            try
            {
                if (lstTournament == null) lstTournament = new List<Model.SYS.SYS_Tournament>();

                if (CacheProvider.IsSet(CacheProvider.CacheKey_Tournament))
                {
                    lstTournament = (List<Model.SYS.SYS_Tournament>)CacheProvider.Get(CacheProvider.CacheKey_Tournament);
                }
                else
                {
                    ResultMessage objResultMessage = new DALEntity.SYS.DAL_Tournament().SelectToCache(ref lstTournament);

                    if (!objResultMessage.IsError)
                    {
                        CacheProvider.Set(CacheProvider.CacheKey_Tournament, lstTournament);
                    }
                    else
                    {
                        return objResultMessage;
                    }
                }
                return new ResultMessage(false, ResultMessage.ErrorTypes.No_Error, "Lấy Cache danh sách giải đấu", string.Empty);
            }
            catch (Exception objEx)
            {
                ResultMessage objResultMessage = new ResultMessage();
                objResultMessage = new ResultMessage(true, ResultMessage.ErrorTypes.GetData, "Lấy Cache danh sách giải đấu", objEx);
                DAL_Error.Insert(objResultMessage, 0, "GetDataCache --> GetTournament");
                return objResultMessage;
            }
        }
    }
}
